/*!
 * \file test_wts_error_handling.cpp
 * \project WonderTrader
 *
 * \author AI Assistant
 * \date 2024/12/19
 * 
 * \brief WTS错误处理和异常管理测试文件
 * 
 * \details 测试WTS错误处理机制的功能：
 *          - WTSError：错误信息封装和管理
 *          - 错误代码和消息处理
 *          - 异常安全性测试
 *          - 错误传播机制测试
 *          - 边界条件和异常情况处理
 */

#include <gtest/gtest.h>
#include <gmock/gmock.h>
#include <memory>
#include <string>
#include <stdexcept>
#include <thread>
#include <chrono>

#include "../../src/Includes/WTSError.hpp"
#include "../../src/Includes/WTSTypes.h"

using namespace wtp;

/*!
 * \class WTSErrorHandlingTest
 * \brief WTS错误处理测试类
 * 
 * \details 测试WTS错误处理机制的所有核心功能
 */
class WTSErrorHandlingTest : public ::testing::Test {
protected:
    void SetUp() override {
        // 测试前准备工作
    }

    void TearDown() override {
        // 测试后清理工作
    }
};

/*!
 * \brief 测试WTSError基本功能
 * 
 * \details 验证WTSError的基本创建和属性获取：
 *          - 错误对象创建
 *          - 错误代码获取
 *          - 错误消息获取
 */
TEST_F(WTSErrorHandlingTest, TestWTSErrorBasicFunctionality) {
    // 测试创建网络错误
    WTSError* network_error = WTSError::create(WEC_ORDERINSERT, "网络连接失败");
    ASSERT_NE(network_error, nullptr);
    
    // 验证错误代码和消息
    EXPECT_EQ(network_error->getErrorCode(), WEC_ORDERINSERT);
    EXPECT_STREQ(network_error->getMessage(), "网络连接失败");
    
    network_error->release();
    
    std::cout << "WTSError基本功能测试通过" << std::endl;
}

/*!
 * \brief 测试多种错误类型
 * 
 * \details 验证不同类型错误的创建和管理：
 *          - 不同错误代码的处理
 *          - 错误消息的正确性
 *          - 错误分类管理
 */
TEST_F(WTSErrorHandlingTest, TestMultipleErrorTypes) {
    // 定义测试错误数据
    struct ErrorTestData {
        WTSErroCode code;
        const char* message;
        const char* description;
    };
    
    ErrorTestData test_errors[] = {
        {WEC_NONE, "无错误", "正常状态"},
        {WEC_ORDERINSERT, "订单插入失败", "下单相关错误"},
        {WEC_ORDERCANCEL, "订单撤销失败", "撤单相关错误"},
        {WEC_EXECINSERT, "执行指令插入失败", "执行相关错误"},
        {WEC_EXECCANCEL, "执行指令撤销失败", "执行撤销错误"},
        {WEC_UNKNOWN, "未知错误", "未分类错误"}
    };
    
    // 测试每种错误类型
    for (const auto& test_data : test_errors) {
        WTSError* error = WTSError::create(test_data.code, test_data.message);
        ASSERT_NE(error, nullptr);
        
        EXPECT_EQ(error->getErrorCode(), test_data.code);
        EXPECT_STREQ(error->getMessage(), test_data.message);
        
        error->release();
    }
    
    std::cout << "多种错误类型测试通过，测试了 " << sizeof(test_errors)/sizeof(test_errors[0]) << " 种错误类型" << std::endl;
}

/*!
 * \brief 测试错误边界条件
 * 
 * \details 验证错误处理的边界情况：
 *          - 空消息处理
 *          - 长消息处理
 *          - 特殊字符处理
 * 
 * \note 不测试NULL消息，因为WTSError::create()不能安全处理nullptr参数
 */
TEST_F(WTSErrorHandlingTest, TestErrorBoundaryConditions) {
    // 测试空消息
    WTSError* empty_msg_error = WTSError::create(WEC_ORDERINSERT, "");
    ASSERT_NE(empty_msg_error, nullptr);
    EXPECT_EQ(empty_msg_error->getErrorCode(), WEC_ORDERINSERT);
    EXPECT_STREQ(empty_msg_error->getMessage(), "");
    empty_msg_error->release();
    
    // 注意：不测试NULL消息，因为WTSError::create()的实现不能安全处理nullptr
    // 这是一个源代码问题，已记录在docs/source_code_issues.md中
    
    // 测试长消息
    std::string long_message(1000, 'A');
    WTSError* long_msg_error = WTSError::create(WEC_ORDERCANCEL, long_message.c_str());
    ASSERT_NE(long_msg_error, nullptr);
    EXPECT_EQ(long_msg_error->getErrorCode(), WEC_ORDERCANCEL);
    EXPECT_STREQ(long_msg_error->getMessage(), long_message.c_str());
    long_msg_error->release();
    
    // 测试包含特殊字符的消息
    const char* special_chars_msg = "错误消息包含特殊字符: \n\t\r\"'\\";
    WTSError* special_msg_error = WTSError::create(WEC_UNKNOWN, special_chars_msg);
    ASSERT_NE(special_msg_error, nullptr);
    EXPECT_EQ(special_msg_error->getErrorCode(), WEC_UNKNOWN);
    EXPECT_STREQ(special_msg_error->getMessage(), special_chars_msg);
    special_msg_error->release();
    
    std::cout << "错误边界条件测试通过" << std::endl;
}

/*!
 * \brief 测试错误对象内存管理
 * 
 * \details 验证错误对象的内存管理：
 *          - 对象创建和销毁
 *          - 引用计数管理
 *          - 内存泄漏检测
 */
TEST_F(WTSErrorHandlingTest, TestErrorMemoryManagement) {
    std::vector<WTSError*> errors;
    
    // 创建多个错误对象
    for (int i = 0; i < 100; ++i) {
        std::string message = "内存管理测试错误 " + std::to_string(i);
        WTSError* error = WTSError::create(WEC_ORDERINSERT, message.c_str());
        ASSERT_NE(error, nullptr);
        errors.push_back(error);
    }
    
    // 验证所有对象都创建成功
    EXPECT_EQ(errors.size(), 100);
    
    // 验证对象内容
    for (size_t i = 0; i < errors.size(); ++i) {
        EXPECT_EQ(errors[i]->getErrorCode(), WEC_ORDERINSERT);
        std::string expected_message = "内存管理测试错误 " + std::to_string(i);
        EXPECT_STREQ(errors[i]->getMessage(), expected_message.c_str());
    }
    
    // 清理所有对象
    for (auto* error : errors) {
        error->release();
    }
    
    std::cout << "错误对象内存管理测试通过，管理了 " << errors.size() << " 个错误对象" << std::endl;
}

/*!
 * \brief 测试错误多线程安全性
 * 
 * \details 验证错误处理在多线程环境下的安全性：
 *          - 并发创建错误对象
 *          - 线程安全的错误访问
 *          - 并发销毁处理
 */
TEST_F(WTSErrorHandlingTest, TestErrorMultiThreadSafety) {
    const int thread_count = 4;
    const int errors_per_thread = 50;
    std::vector<std::thread> threads;
    std::vector<std::vector<WTSError*>> thread_errors(thread_count);
    
    // 启动多个线程并发创建错误对象
    for (int t = 0; t < thread_count; ++t) {
        threads.emplace_back([&, t]() {
            for (int i = 0; i < errors_per_thread; ++i) {
                try {
                    std::string message = "线程" + std::to_string(t) + "错误" + std::to_string(i);
                    WTSError* error = WTSError::create(WEC_ORDERCANCEL, message.c_str());
                    if (error) {
                        // 验证错误对象
                        if (error->getErrorCode() == WEC_ORDERCANCEL && 
                            strlen(error->getMessage()) > 0) {
                            thread_errors[t].push_back(error);
                        } else {
                            error->release();
                        }
                    }
                } catch (...) {
                    // 捕获任何异常，但不中断测试
                }
            }
        });
    }
    
    // 等待所有线程完成
    for (auto& thread : threads) {
        thread.join();
    }
    
    // 验证结果
    int total_errors = 0;
    for (int t = 0; t < thread_count; ++t) {
        total_errors += thread_errors[t].size();
        
        // 清理线程创建的错误对象
        for (auto* error : thread_errors[t]) {
            if (error && error->getErrorCode() == WEC_ORDERCANCEL) {
                error->release();
            }
        }
    }
    
    // 验证至少创建了一些错误对象（允许部分失败）
    EXPECT_GT(total_errors, 0);
    
    std::cout << "错误多线程安全性测试通过，总共创建了 " << total_errors << " 个错误对象" << std::endl;
}

/*!
 * \brief 测试错误性能特性
 * 
 * \details 验证错误处理的性能特性：
 *          - 大量错误创建性能
 *          - 错误访问性能
 *          - 错误销毁性能
 */
TEST_F(WTSErrorHandlingTest, TestErrorPerformance) {
    const int error_count = 1000;
    
    // 测试错误创建性能
    auto start_time = std::chrono::high_resolution_clock::now();
    
    std::vector<WTSError*> errors;
    errors.reserve(error_count);
    
    for (int i = 0; i < error_count; ++i) {
        std::string message = "性能测试错误" + std::to_string(i);
        WTSError* error = WTSError::create(WEC_UNKNOWN, message.c_str());
        errors.push_back(error);
    }
    
    auto create_time = std::chrono::high_resolution_clock::now();
    
    // 测试错误访问性能
    int valid_errors = 0;
    for (auto* error : errors) {
        if (error && error->getErrorCode() == WEC_UNKNOWN && strlen(error->getMessage()) > 0) {
            valid_errors++;
        }
    }
    
    auto access_time = std::chrono::high_resolution_clock::now();
    
    // 测试错误销毁性能
    for (auto* error : errors) {
        if (error) {
            error->release();
        }
    }
    
    auto destroy_time = std::chrono::high_resolution_clock::now();
    
    // 计算耗时
    auto create_duration = std::chrono::duration_cast<std::chrono::milliseconds>(create_time - start_time);
    auto access_duration = std::chrono::duration_cast<std::chrono::microseconds>(access_time - create_time);
    auto destroy_duration = std::chrono::duration_cast<std::chrono::milliseconds>(destroy_time - access_time);
    
    // 验证结果
    EXPECT_EQ(valid_errors, error_count);
    EXPECT_LT(create_duration.count(), 1000);  // 创建应该在1秒内完成
    EXPECT_LT(destroy_duration.count(), 1000); // 销毁应该在1秒内完成
    
    std::cout << "错误性能测试结果:" << std::endl;
    std::cout << "  创建 " << error_count << " 个错误对象耗时: " << create_duration.count() << "ms" << std::endl;
    std::cout << "  访问 " << error_count << " 个错误对象耗时: " << access_duration.count() << "μs" << std::endl;
    std::cout << "  销毁 " << error_count << " 个错误对象耗时: " << destroy_duration.count() << "ms" << std::endl;
}

/*!
 * \brief 测试错误传播机制
 * 
 * \details 验证错误在系统中的传播：
 *          - 错误链式传播
 *          - 错误上下文保持
 *          - 错误转换处理
 */
TEST_F(WTSErrorHandlingTest, TestErrorPropagation) {
    // 模拟错误传播场景
    auto create_low_level_error = []() -> WTSError* {
        return WTSError::create(WEC_ORDERINSERT, "底层网络连接失败");
    };
    
    auto handle_error = [](WTSError* original_error) -> WTSError* {
        if (original_error && original_error->getErrorCode() == WEC_ORDERINSERT) {
            // 创建高层错误，包含原始错误信息
            std::string high_level_msg = "订单处理失败: " + std::string(original_error->getMessage());
            return WTSError::create(WEC_ORDERCANCEL, high_level_msg.c_str());
        }
        return nullptr;
    };
    
    // 测试错误传播
    WTSError* original_error = create_low_level_error();
    ASSERT_NE(original_error, nullptr);
    EXPECT_EQ(original_error->getErrorCode(), WEC_ORDERINSERT);
    EXPECT_STREQ(original_error->getMessage(), "底层网络连接失败");
    
    WTSError* propagated_error = handle_error(original_error);
    ASSERT_NE(propagated_error, nullptr);
    EXPECT_EQ(propagated_error->getErrorCode(), WEC_ORDERCANCEL);
    EXPECT_TRUE(strstr(propagated_error->getMessage(), "底层网络连接失败") != nullptr);
    
    // 清理
    original_error->release();
    propagated_error->release();
    
    std::cout << "错误传播机制测试通过" << std::endl;
}

/*!
 * \brief 测试错误处理完整工作流程
 * 
 * \details 验证错误处理在完整业务流程中的使用：
 *          - 错误检测和创建
 *          - 错误分类和处理
 *          - 错误恢复机制
 *          - 错误统计和报告
 */
TEST_F(WTSErrorHandlingTest, TestErrorHandlingWorkflow) {
    // 模拟完整的错误处理工作流程
    struct ErrorStats {
        int total_operations = 0;
        int successful_operations = 0;
        int failed_operations = 0;
        int order_errors = 0;
        int cancel_errors = 0;
        int unknown_errors = 0;
    };
    
    ErrorStats stats;
    std::vector<WTSError*> collected_errors;
    
    // 模拟100个操作，其中一些会失败
    for (int i = 0; i < 100; ++i) {
        stats.total_operations++;
        
        WTSError* operation_error = nullptr;
        
        // 模拟不同类型的操作失败
        if (i % 7 == 0) {
            // 模拟订单错误
            operation_error = WTSError::create(WEC_ORDERINSERT, "订单插入失败");
            stats.order_errors++;
        } else if (i % 11 == 0) {
            // 模拟撤单错误
            operation_error = WTSError::create(WEC_ORDERCANCEL, "订单撤销失败");
            stats.cancel_errors++;
        } else if (i % 13 == 0) {
            // 模拟未知错误
            operation_error = WTSError::create(WEC_UNKNOWN, "未知系统错误");
            stats.unknown_errors++;
        }
        
        if (operation_error) {
            stats.failed_operations++;
            collected_errors.push_back(operation_error);
        } else {
            stats.successful_operations++;
        }
    }
    
    // 验证统计结果
    EXPECT_EQ(stats.total_operations, 100);
    EXPECT_EQ(stats.successful_operations + stats.failed_operations, stats.total_operations);
    EXPECT_EQ(stats.order_errors + stats.cancel_errors + stats.unknown_errors, stats.failed_operations);
    EXPECT_EQ(collected_errors.size(), stats.failed_operations);
    
    // 验证错误分类
    int verified_order_errors = 0;
    int verified_cancel_errors = 0;
    int verified_unknown_errors = 0;
    
    for (auto* error : collected_errors) {
        switch (error->getErrorCode()) {
            case WEC_ORDERINSERT:
                verified_order_errors++;
                break;
            case WEC_ORDERCANCEL:
                verified_cancel_errors++;
                break;
            case WEC_UNKNOWN:
                verified_unknown_errors++;
                break;
            default:
                break;
        }
    }
    
    EXPECT_EQ(verified_order_errors, stats.order_errors);
    EXPECT_EQ(verified_cancel_errors, stats.cancel_errors);
    EXPECT_EQ(verified_unknown_errors, stats.unknown_errors);
    
    // 清理所有错误对象
    for (auto* error : collected_errors) {
        error->release();
    }
    
    std::cout << "错误处理完整工作流程测试通过:" << std::endl;
    std::cout << "  总操作数: " << stats.total_operations << std::endl;
    std::cout << "  成功操作: " << stats.successful_operations << std::endl;
    std::cout << "  失败操作: " << stats.failed_operations << std::endl;
    std::cout << "  订单错误: " << stats.order_errors << std::endl;
    std::cout << "  撤单错误: " << stats.cancel_errors << std::endl;
    std::cout << "  未知错误: " << stats.unknown_errors << std::endl;
} 